Java in 10 Minuten lernen

9 July 2025 — Programmiersprache

Java ist eine hochrangige, objektorientierte Programmiersprache, die für ihr “einmal schreiben, überall ausführen”-Prinzip bekannt ist. Dieses Tutorial behandelt Java 21+ Features und hilft Ihnen, Java-Grundlagen schnell zu erlernen.

1. Ihr erstes Java-Programm schreiben

Java-Programme sind in Klassen organisiert. Beginnen wir mit einem einfachen Programm. Erstellen Sie eine Datei namens HelloWorld.java:

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

Kompilieren und führen Sie das Programm aus:

javac HelloWorld.java
java HelloWorld

Die Ausgabe wird sein:

Hello, World!

Dieses einfache Programm demonstriert Javas Grundstruktur. Jedes Java-Programm muss mindestens eine Klasse haben, und die main-Methode ist der Einstiegspunkt.

2. Grundlegende Syntax

Java-Syntax ist strukturiert und folgt spezifischen Regeln:

// Dies ist ein einzeiliger Kommentar
/* Dies ist ein
   mehrzeiliger Kommentar */

public class BasicSyntax {
    public static void main(String[] args) {
        System.out.println("Hello, Java!");
    }
}

Grundlegende Syntaxregeln in Java:

Groß-/Kleinschreibung: Java ist case-sensitive. Variable und variable sind unterschiedlich.
Klassennamen: Sollten mit einem Großbuchstaben beginnen und der CamelCase-Konvention folgen.
Methodennamen: Sollten mit einem Kleinbuchstaben beginnen und der camelCase-Konvention folgen.
Semikolons: Jede Anweisung muss mit einem Semikolon ; enden.
Geschweifte Klammern: Codeblöcke werden mit geschweiften Klammern {} definiert.
Kommentare: Einzeilige Kommentare verwenden //, mehrzeilige Kommentare verwenden /* */.

3. Variablen und Datentypen

Java ist eine statisch typisierte Sprache, was bedeutet, dass Sie Variablentypen explizit deklarieren müssen.

Regeln für Variablennamen:

Müssen mit einem Buchstaben, Unterstrich _ oder Dollarzeichen $ beginnen.
Können Buchstaben, Ziffern, Unterstriche und Dollarzeichen enthalten.
Können nicht Java-Schlüsselwörter sein.
Sollten der camelCase-Konvention folgen.

Javas primitive Datentypen:

byte: 8-Bit signed integer (-128 bis 127)
short: 16-Bit signed integer (-32,768 bis 32,767)
int: 32-Bit signed integer (-2^31 bis 2^31-1)
long: 64-Bit signed integer (-2^63 bis 2^63-1)
float: 32-Bit Gleitkommazahl
double: 64-Bit Gleitkommazahl
boolean: true oder false
char: 16-Bit Unicode-Zeichen

public class DataTypes {
    public static void main(String[] args) {
        // Integer-Typen
        byte age = 25;
        short year = 2024;
        int population = 1000000;
        long distance = 93000000L; // L-Suffix für long
        
        // Gleitkomma-Typen
        float temperature = 36.5f; // f-Suffix für float
        double pi = 3.14159265359;
        
        // Boolean und Zeichen
        boolean isActive = true;
        char grade = 'A';
        
        // String (Referenztyp)
        String name = "Alice";
        
        System.out.println("Name: " + name + ", Age: " + age);
    }
}

3.1 String-Operationen

Strings in Java sind Objekte, keine primitiven Typen:

public class StringExample {
    public static void main(String[] args) {
        String text = "Java Programming";
        
        System.out.println("Length: " + text.length());
        System.out.println("Uppercase: " + text.toUpperCase());
        System.out.println("Lowercase: " + text.toLowerCase());
        System.out.println("Character at index 0: " + text.charAt(0));
        System.out.println("Substring: " + text.substring(0, 4));
        System.out.println("Contains 'Java': " + text.contains("Java"));
        
        // String-Verkettung
        String greeting = "Hello, " + "World!";
        System.out.println(greeting);
        
        // String-Formatierung
        String formatted = String.format("Pi is approximately %.2f", 3.14159);
        System.out.println(formatted);
    }
}

4. Arrays und Collections

4.1 Arrays

Arrays speichern mehrere Werte desselben Typs:

public class ArrayExample {
    public static void main(String[] args) {
        // Array-Deklaration und Initialisierung
        int[] numbers = {1, 2, 3, 4, 5};
        String[] fruits = new String[3];
        fruits[0] = "apple";
        fruits[1] = "banana";
        fruits[2] = "orange";
        
        // Zugriff auf Array-Elemente
        System.out.println("First number: " + numbers[0]);
        System.out.println("Array length: " + numbers.length);
        
        // Iteration durch Arrays
        for (int i = 0; i < numbers.length; i++) {
            System.out.println("Number " + i + ": " + numbers[i]);
        }
        
        // Erweiterte for-Schleife (for-each)
        for (String fruit : fruits) {
            System.out.println("Fruit: " + fruit);
        }
        
        // Mehrdimensionale Arrays
        int[][] matrix = {{1, 2}, {3, 4}, {5, 6}};
        System.out.println("Matrix element [1][1]: " + matrix[1][1]);
    }
}

4.2 Collections

Das Java Collections Framework bietet dynamische Datenstrukturen:

import java.util.*;

public class CollectionsExample {
    public static void main(String[] args) {
        // ArrayList (dynamisches Array)
        ArrayList<String> names = new ArrayList<>();
        names.add("Alice");
        names.add("Bob");
        names.add("Charlie");
        names.remove("Bob");
        System.out.println("Names: " + names);
        
        // HashMap (Schlüssel-Wert-Paare)
        HashMap<String, Integer> ages = new HashMap<>();
        ages.put("Alice", 25);
        ages.put("Bob", 30);
        ages.put("Charlie", 35);
        System.out.println("Alice's age: " + ages.get("Alice"));
        
        // HashSet (eindeutige Elemente)
        HashSet<Integer> uniqueNumbers = new HashSet<>();
        uniqueNumbers.add(1);
        uniqueNumbers.add(2);
        uniqueNumbers.add(2); // Duplikat, wird nicht hinzugefügt
        uniqueNumbers.add(3);
        System.out.println("Unique numbers: " + uniqueNumbers);
        
        // Iteration durch Collections
        for (String name : names) {
            System.out.println("Name: " + name);
        }
        
        for (Map.Entry<String, Integer> entry : ages.entrySet()) {
            System.out.println(entry.getKey() + ": " + entry.getValue());
        }
    }
}

5. Operationen und Operatoren

Java bietet verschiedene Operatoren für verschiedene Operationen:

Arithmetische Operatoren: +, -, *, /, % (Modulo), ++ (Inkrement), -- (Dekrement)
Vergleichsoperatoren: ==, !=, >, <, >=, <=
Logische Operatoren: && (und), || (oder), ! (nicht)
Bitweise Operatoren: &, |, ^, ~, <<, >>, >>>
Zuweisungsoperatoren: =, +=, -=, *=, /=, %=

public class OperatorsExample {
    public static void main(String[] args) {
        int a = 10, b = 3;
        
        // Arithmetische Operationen
        System.out.println("Addition: " + (a + b));
        System.out.println("Subtraction: " + (a - b));
        System.out.println("Multiplication: " + (a * b));
        System.out.println("Division: " + (a / b));
        System.out.println("Modulus: " + (a % b));
        
        // Inkrement und Dekrement
        System.out.println("Pre-increment: " + (++a));
        System.out.println("Post-decrement: " + (b--));
        
        // Vergleichsoperationen
        System.out.println("Equal: " + (a == b));
        System.out.println("Not equal: " + (a != b));
        System.out.println("Greater than: " + (a > b));
        
        // Logische Operationen
        boolean x = true, y = false;
        System.out.println("AND: " + (x && y));
        System.out.println("OR: " + (x || y));
        System.out.println("NOT: " + (!x));
        
        // Zuweisungsoperationen
        int c = 5;
        c += 3; // c = c + 3
        System.out.println("After += 3: " + c);
    }
}

6. Kontrollfluss

6.1 Bedingte Anweisungen

public class ConditionalExample {
    public static void main(String[] args) {
        int score = 85;
        
        // if-else Anweisung
        if (score >= 90) {
            System.out.println("Grade: A");
        } else if (score >= 80) {
            System.out.println("Grade: B");
        } else if (score >= 70) {
            System.out.println("Grade: C");
        } else {
            System.out.println("Grade: F");
        }
        
        // Ternärer Operator
        String result = (score >= 60) ? "Pass" : "Fail";
        System.out.println("Result: " + result);
        
        // switch-Anweisung
        char grade = 'B';
        switch (grade) {
            case 'A':
                System.out.println("Excellent!");
                break;
            case 'B':
                System.out.println("Good!");
                break;
            case 'C':
                System.out.println("Average");
                break;
            default:
                System.out.println("Invalid grade");
        }
    }
}

6.2 Schleifen

public class LoopExample {
    public static void main(String[] args) {
        // for-Schleife
        System.out.println("For loop:");
        for (int i = 0; i < 5; i++) {
            System.out.println("Iteration: " + i);
        }
        
        // Erweiterte for-Schleife (for-each)
        System.out.println("\nFor-each loop:");
        int[] numbers = {1, 2, 3, 4, 5};
        for (int num : numbers) {
            System.out.println("Number: " + num);
        }
        
        // while-Schleife
        System.out.println("\nWhile loop:");
        int count = 0;
        while (count < 3) {
            System.out.println("Count: " + count);
            count++;
        }
        
        // do-while-Schleife
        System.out.println("\nDo-while loop:");
        int x = 0;
        do {
            System.out.println("X: " + x);
            x++;
        } while (x < 3);
        
        // break und continue
        System.out.println("\nBreak and continue:");
        for (int i = 0; i < 10; i++) {
            if (i == 5) {
                break; // Schleife verlassen
            }
            if (i % 2 == 0) {
                continue; // Gerade Zahlen überspringen
            }
            System.out.println("Odd number: " + i);
        }
    }
}

7. Methoden (Funktionen)

Methoden in Java sind Funktionen, die zu Klassen gehören:

public class MethodExample {
    
    // Methode ohne Parameter und ohne Rückgabewert
    public static void greet() {
        System.out.println("Hello, World!");
    }
    
    // Methode mit Parametern und Rückgabewert
    public static int add(int a, int b) {
        return a + b;
    }
    
    // Methode mit mehreren Parametern
    public static String formatName(String firstName, String lastName) {
        return firstName + " " + lastName;
    }
    
    // Methodenüberladung (gleicher Name, verschiedene Parameter)
    public static int multiply(int a, int b) {
        return a * b;
    }
    
    public static double multiply(double a, double b) {
        return a * b;
    }
    
    // Variable Argumente (varargs)
    public static int sum(int... numbers) {
        int total = 0;
        for (int num : numbers) {
            total += num;
        }
        return total;
    }
    
    public static void main(String[] args) {
        greet();
        
        int result = add(5, 3);
        System.out.println("Addition result: " + result);
        
        String fullName = formatName("John", "Doe");
        System.out.println("Full name: " + fullName);
        
        System.out.println("Multiply integers: " + multiply(4, 5));
        System.out.println("Multiply doubles: " + multiply(2.5, 3.0));
        
        System.out.println("Sum of multiple numbers: " + sum(1, 2, 3, 4, 5));
    }
}

8. Objektorientierte Programmierung

8.1 Klassen und Objekte

public class Person {
    // Instanzvariablen (Felder)
    private String name;
    private int age;
    private String email;
    
    // Konstruktor
    public Person(String name, int age, String email) {
        this.name = name;
        this.age = age;
        this.email = email;
    }
    
    // Standard-Konstruktor
    public Person() {
        this("Unknown", 0, "");
    }
    
    // Getter-Methoden
    public String getName() {
        return name;
    }
    
    public int getAge() {
        return age;
    }
    
    public String getEmail() {
        return email;
    }
    
    // Setter-Methoden
    public void setName(String name) {
        this.name = name;
    }
    
    public void setAge(int age) {
        if (age >= 0) {
            this.age = age;
        }
    }
    
    public void setEmail(String email) {
        this.email = email;
    }
    
    // Instanzmethode
    public void introduce() {
        System.out.println("Hi, I'm " + name + ", " + age + " years old.");
    }
    
    // Methode mit Logik
    public boolean isAdult() {
        return age >= 18;
    }
    
    // toString-Methode (überschreibt Objects toString)
    @Override
    public String toString() {
        return "Person{name='" + name + "', age=" + age + ", email='" + email + "'}";
    }
    
    public static void main(String[] args) {
        // Objekte erstellen
        Person person1 = new Person("Alice", 25, "[email protected]");
        Person person2 = new Person();
        
        // Methoden verwenden
        person1.introduce();
        System.out.println("Is adult: " + person1.isAdult());
        
        person2.setName("Bob");
        person2.setAge(17);
        person2.setEmail("[email protected]");
        
        System.out.println(person1.toString());
        System.out.println(person2.toString());
    }
}

Dieses umfassende Java-Tutorial behandelt die wesentlichen Konzepte, die für den Einstieg in die Java-Programmierung erforderlich sind. Die starke Typisierung der Sprache, objektorientierte Features und umfangreiche Standardbibliothek machen sie mächtig für das Erstellen robuster Anwendungen. Üben Sie diese Beispiele und experimentieren Sie mit dem Code, um Ihr Verständnis der Java-Programmierkonzepte zu vertiefen.